import * as THREE from 'three';
import { CameraController } from '../CameraController.js';
import { ScaleGrid } from '../ScaleGrid.js';
import { TransformControlsManager } from '../TransformControlsManager.js';

// 场景基类 - 所有场景都继承此类
export class BaseScene {
    constructor(name) {
        this.name = name;
        this.scene = new THREE.Scene();
        this.camera = null;
        this.cameraController = null; // 统一的相机控制器
        this.transformControlsManager = null; // Transform 控制器管理器
        this.scaleGrid = null; // 比例尺网格
        this.objects = []; // 存储场景中的对象，方便管理
        this.lights = [];
        this.isActive = false;
        this.mode = 'edit'; // 'edit' 或 'presentation'
        this.raycaster = new THREE.Raycaster(); // 用于点击检测
        this.mouse = new THREE.Vector2(); // 鼠标位置
        this.renderer = null; // 保存渲染器引用
        
        // 用于区分点击和拖拽
        this.mouseDownPosition = null;
        this.mouseMoveThreshold = 5; // 移动超过5像素认为是拖拽
    }

    // 初始化场景 - 子类必须实现
    init() {
        throw new Error('子类必须实现 init() 方法');
    }

    /**
     * 设置相机控制器（统一的平移、旋转、缩放功能）
     * 子类在创建相机后应该调用此方法
     * @param {WebGLRenderer} renderer - Three.js 渲染器
     * @param {Object} options - 可选配置参数
     */
    setupCameraController(renderer, options = {}) {
        if (!this.camera) {
            console.warn('⚠️ 请先创建相机再设置相机控制器');
            return;
        }

        // 保存渲染器引用
        this.renderer = renderer;

        // 创建相机控制器
        this.cameraController = new CameraController(this.camera, renderer.domElement);
        
        // 应用配置
        if (options.target) {
            this.cameraController.setTarget(
                options.target.x || 0,
                options.target.y || 0,
                options.target.z || 0
            );
        } else {
            this.cameraController.setTarget(0, 0, 0);
        }
        
        if (options.minDistance !== undefined) {
            this.cameraController.minDistance = options.minDistance;
        }
        
        if (options.maxDistance !== undefined) {
            this.cameraController.maxDistance = options.maxDistance;
        }
        
        if (options.rotateSpeed !== undefined) {
            this.cameraController.rotateSpeed = options.rotateSpeed;
        }
        
        if (options.panSpeed !== undefined) {
            this.cameraController.panSpeed = options.panSpeed;
        }
        
        if (options.zoomSpeed !== undefined) {
            this.cameraController.zoomSpeed = options.zoomSpeed;
        }
        
        // 设置点击检测
        this.setupClickDetection(renderer.domElement);
    }

    /**
     * 设置 Transform 控制器管理器
     * @param {WebGLRenderer} renderer - Three.js 渲染器
     */
    setupTransformControls(renderer) {
        if (!this.camera) {
            console.warn('⚠️ 请先创建相机再设置 Transform 控制器');
            return;
        }
        
        if (!this.cameraController) {
            console.warn('⚠️ 请先设置相机控制器再设置 Transform 控制器');
            return;
        }
        
        // 创建 Transform 控制器管理器
        this.transformControlsManager = new TransformControlsManager(
            this.scene,
            this.camera,
            renderer,
            this.cameraController
        );
    }

    /**
     * 获取 Transform 控制器管理器
     */
    getTransformControls() {
        return this.transformControlsManager;
    }

    /**
     * 设置场景点击检测
     * @param {HTMLElement} domElement - 渲染器的DOM元素
     */
    setupClickDetection(domElement) {
        // 绑定点击事件
        this.handleClickBound = this.handleClick.bind(this);
        this.handleMouseDownBound = this.handleMouseDown.bind(this);
        this.handleMouseMoveBound = this.handleMouseMove.bind(this);
        
        domElement.addEventListener('click', this.handleClickBound);
        domElement.addEventListener('mousedown', this.handleMouseDownBound);
        domElement.addEventListener('mousemove', this.handleMouseMoveBound);
    }
    
    /**
     * 记录鼠标按下位置
     */
    handleMouseDown(event) {
        this.mouseDownPosition = {
            x: event.clientX,
            y: event.clientY,
            isDragging: false
        };
    }
    
    /**
     * 检测鼠标移动（用于判断是否是拖拽）
     */
    handleMouseMove(event) {
        // 如果没有记录按下位置，不处理
        if (!this.mouseDownPosition) return;
        
        // 计算移动距离
        const dx = event.clientX - this.mouseDownPosition.x;
        const dy = event.clientY - this.mouseDownPosition.y;
        const distance = Math.sqrt(dx * dx + dy * dy);
        
        // 如果移动超过阈值，标记为拖拽
        if (distance > this.mouseMoveThreshold) {
            this.mouseDownPosition.isDragging = true;
        }
    }

    /**
     * 处理场景点击事件
     * @param {MouseEvent} event - 鼠标事件
     */
    handleClick(event) {
        // 1. 检查是否是拖拽操作（鼠标移动超过阈值）
        const isMouseDragging = this.mouseDownPosition?.isDragging;
        
        // 2. 检查是否正在拖拽TransformControls或相机
        const isTransformDragging = this.transformControlsManager?.transformControls?.dragging;
        const isCameraDragging = this.cameraController?.currentState !== this.cameraController?.state.NONE;
        // 清除鼠标按下位置记录
        this.mouseDownPosition = null;
        
        if (isMouseDragging || isTransformDragging || isCameraDragging) {
            return;
        }

        // 计算鼠标位置（归一化设备坐标）
        const rect = this.renderer.domElement.getBoundingClientRect();
        this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
        this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
        // 更新raycaster
        this.raycaster.setFromCamera(this.mouse, this.camera);

        // 获取场景中所有可交互的对象（包括mesh和包围盒辅助对象）
        const intersectableObjects = [];
        
        // 获取TransformControls引用，用于排除其所有子对象
        const transformControls = this.transformControlsManager?.transformControls;
        
        this.scene.traverse((object) => {
            // 检测两类对象：
            // 1. 模型节点下的mesh
            // 2. 包围盒辅助对象（BoxHelper）
            
            // ✅ 排除TransformControls及其所有子对象（完全排除）
            if (transformControls) {
                let parent = object;
                while (parent) {
                    if (parent === transformControls) {
                        // 这个对象是TransformControls或其子对象，跳过
                        return;
                    }
                    parent = parent.parent;
                }
            }
            
            // 排除不应该参与点击检测的对象：
            // - TransformControls相关对象（双重保险）
            // - 坐标轴和比例尺（ScaleGrid）
            // - 辅助线、网格等
            if (object.type === 'TransformControlsPlane' || 
                object.type === 'TransformControlsGizmo' ||
                object.type === 'GridHelper' ||
                object.type === 'AxesHelper' ||
                object.type === 'LineSegments' || // 坐标轴线段
                object.userData?.isScaleGrid || // ScaleGrid标记
                object.userData?.isHelper || // 通用辅助对象标记
                object.name?.includes('ScaleGrid') || // ScaleGrid对象
                object.name?.includes('__')) { // 其他辅助对象
                return;
            }
            
            // 包围盒辅助对象（用于mesh选中时的轮廓高亮）
            if (object.isBoxHelper) {
                intersectableObjects.push(object);
            }
            // 模型节点下的mesh
            else if (object.parent === this.scene && 
                !object.isLight && 
                !object.isCamera && 
                !object.userData?.isGround) {
                
                // 将模型节点及其所有子对象中的mesh添加到检测列表
                object.traverse((child) => {
                    // 只添加真正的mesh，排除所有辅助对象
                    if (child.isMesh && 
                        child.type !== 'TransformControlsPlane' && 
                        child.type !== 'TransformControlsGizmo' &&
                        !child.userData?.isHelper &&
                        !child.userData?.isScaleGrid) {
                        intersectableObjects.push(child);
                    }
                    // ✅ 允许点击相机辅助对象
                    else if (child.type === 'CameraHelper') {
                        intersectableObjects.push(child);
                    }
                });
            }
        });
        if (intersectableObjects.length > 0) {
        }

        // 执行射线检测
        // ⚡ 增加线段检测阈值，使相机线框更容易点击
        const originalThreshold = this.raycaster.params.Line.threshold;
        this.raycaster.params.Line.threshold = 0.5;
        
        const intersects = this.raycaster.intersectObjects(intersectableObjects, false);
        
        // 恢复默认阈值
        this.raycaster.params.Line.threshold = originalThreshold;
        
        if (intersects.length > 0) {
            // 点击到了对象（mesh或包围盒）
            let clickedObject = intersects[0].object;
            
            // 如果点击的是包围盒，获取其关联的对象
            if (clickedObject.isBoxHelper) {
                clickedObject = clickedObject.object || clickedObject;
            }
            // ✅ 如果点击的是相机辅助对象，获取其关联的相机
            else if (clickedObject.type === 'CameraHelper' && clickedObject.camera) {
                clickedObject = clickedObject.camera;
            }
            
            // 向上查找第一个场景树节点（而不是一直找到最上级）
            let searchPath = [clickedObject.name || '(unnamed)'];
            let foundNode = null;
            let currentObject = clickedObject;
            
            // 从点击的对象开始向上查找，找到第一个在场景树中的节点就停止
            if (window.sceneTreeManager) {
                while (currentObject) {
                    // 检查当前对象是否在场景树中
                    const node = window.sceneTreeManager.findNodeByObject3D(currentObject);
                    if (node) {
                        // 找到第一个场景树节点，停止查找
                        foundNode = node;
                        break;
                    }
                    
                    // 继续向上查找
                    if (currentObject.parent && currentObject.parent !== this.scene) {
                        currentObject = currentObject.parent;
                        searchPath.push(currentObject.name || '(unnamed)');
                    } else {
                        // 已经到达根节点，停止
                        break;
                    }
                }
                
                // 选中找到的节点
                if (foundNode) {
                    // 选中节点，会触发nodeSelected事件，SceneTreeUI会自动处理UI更新和轮廓效果
                    window.sceneTreeManager.selectNode(foundNode.id);
                } else {
                    // 点击到了对象但不在场景树中（可能是未排除的辅助对象），视为点击空白处，执行取消选择
                    this._deselectAll();
                }
            } else {
                // sceneTreeManager 不存在，可能未初始化，尝试取消选择作为回退
                this._deselectAll();
            }
        } else {
            // 未点到任何mesh和包围盒，执行取消选择
            this._deselectAll();
        }
    }

    /**
     * 执行取消选择的所有逻辑
     * 包括退出mesh编辑模式和取消节点选择
     * @private
     */
    _deselectAll() {
        // 检查是否有mesh在mesh结构面板中被选中（mesh编辑模式）
        const meshPanel = document.getElementById('mesh-structure-panel');
        const hasMeshSelected = meshPanel && 
                               meshPanel.classList.contains('active') && 
                               meshPanel.querySelector('.mesh-tree-node.selected');
        
        if (hasMeshSelected) {
            // 有mesh已选中，退出mesh编辑模式
            if (window.sceneTreeUI && typeof window.sceneTreeUI.exitMeshEditMode === 'function') {
                window.sceneTreeUI.exitMeshEditMode();
            }
            return;
        }
        
        // 没有mesh选中，取消当前选中的节点
        if (window.sceneTreeManager && window.sceneTreeManager.selectedNode) {
            // 调用deselectNode会触发nodeDeselected事件，SceneTreeUI.clearSelection会统一处理所有清理逻辑
            window.sceneTreeManager.deselectNode();
        }
    }

    // 更新场景 - 每帧调用（可选）
    update(deltaTime) {
        // 更新相机控制器
        if (this.cameraController) {
            this.cameraController.update();
        }
        
        // 更新屏幕比例尺（实时显示当前视野的尺度）
        if (this.scaleGrid && this.camera) {
            this.scaleGrid.updateScreenScale();
        }
        
        // 更新轮廓高亮效果（使其跟随对象移动）
        if (window.sceneTreeUI && typeof window.sceneTreeUI.updateOutlineEffect === 'function') {
            try {
                window.sceneTreeUI.updateOutlineEffect();
            } catch (error) {
                // 静默处理错误，避免影响渲染循环
                console.warn('⚠️ 更新轮廓效果时出错:', error);
            }
        }
        
        // 子类可以重写此方法实现动画逻辑
        // 但要记得调用 super.update(deltaTime) 以保持相机控制器更新
    }

    /**
     * 初始化比例尺（仅屏幕UI）
     * @param {number} gridSize - 网格大小（米）- 已弃用，仅保留参数兼容性
     */
    setupScaleGrid(gridSize = 50) {
        if (!this.scaleGrid) {
            this.scaleGrid = new ScaleGrid();
            
            // 关联场景（用于获取包围盒）
            if (this.scene) {
                this.scaleGrid.setScene(this.scene);
            }
            
            // 关联相机和相机控制器（用于屏幕比例尺计算）
            if (this.camera) {
                this.scaleGrid.setCamera(this.camera, this.cameraController);
            }
            
            // 根据当前模式显示/隐藏比例尺
            if (this.mode === 'presentation') {
                this.scaleGrid.hide();
            } else {
                this.scaleGrid.show();
            }
        }
    }

    /**
     * 设置场景模式
     * @param {string} mode - 'edit' 或 'presentation'
     */
    setMode(mode) {
        this.mode = mode;
        
        // 根据模式控制比例尺显示
        if (this.scaleGrid) {
            if (mode === 'presentation') {
                this.scaleGrid.hide();
            } else {
                this.scaleGrid.show();
            }
        }
    }

    /**
     * 切换比例尺显示
     */
    toggleScaleGrid() {
        if (this.scaleGrid) {
            this.scaleGrid.toggle();
        }
    }

    /**
     * 切换参考地面显示
     */
    toggleGroundPlane() {
        // 遍历场景中所有标记为地面的对象
        this.scene.traverse((object) => {
            if (object.userData && object.userData.isGround) {
                object.visible = !object.visible;
            }
        });
    }

    // 激活场景
    activate() {
        this.isActive = true;
    }

    // 停用场景
    deactivate() {
        this.isActive = false;
    }

    // 清理场景资源
    dispose() {
        // 移除点击事件监听器
        if (this.renderer) {
            if (this.handleClickBound) {
                this.renderer.domElement.removeEventListener('click', this.handleClickBound);
                this.handleClickBound = null;
            }
            if (this.handleMouseDownBound) {
                this.renderer.domElement.removeEventListener('mousedown', this.handleMouseDownBound);
                this.handleMouseDownBound = null;
            }
            if (this.handleMouseMoveBound) {
                this.renderer.domElement.removeEventListener('mousemove', this.handleMouseMoveBound);
                this.handleMouseMoveBound = null;
            }
        }
        
        // 清理 Transform 控制器
        if (this.transformControlsManager) {
            this.transformControlsManager.dispose();
            this.transformControlsManager = null;
        }
        
        // 清理相机控制器
        if (this.cameraController) {
            this.cameraController.dispose();
            this.cameraController = null;
        }
        
        // 清理比例尺
        if (this.scaleGrid) {
            this.scaleGrid.dispose();
            this.scaleGrid = null;
        }
        
        // 清理几何体和材质
        this.objects.forEach(obj => {
            if (obj.geometry) obj.geometry.dispose();
            if (obj.material) {
                if (Array.isArray(obj.material)) {
                    obj.material.forEach(mat => mat.dispose());
                } else {
                    obj.material.dispose();
                }
            }
        });
        
        // 清空场景
        while(this.scene.children.length > 0) {
            this.scene.remove(this.scene.children[0]);
        }
        
        this.renderer = null;
    }

    // 获取场景对象
    getScene() {
        return this.scene;
    }

    // 获取相机
    getCamera() {
        return this.camera;
    }
}

